Developer CD Series 1996 May: Tool Chest

home *** CD-ROM | disk | FTP | other *** search

/ Developer CD Series 1996 May: Tool Chest / Developer CD Series May 1996 (Tool Chest) (Apple Computer) (1996).iso / Tool Chest / Development Tools & Languages / Dylan Related / J-Dylan info / DIRMJ - Common Ground / Chap.1-7 (.txt) < prev next >

Wrap

Common Ground | 1994-12-13 | 578.3 KB | 2,300 lines | [CGDC/CGVM]

Palatino Introduction) Manual Notation) Roman (Bold) Courier Courier {...} number <number> string <string> Dylan Courier Courier Courier Courier Dylan format print Dylan Dylan Dylan Palatino Background and Goals) Dylan Dylan Dylan Dylan Dylan 8 Smalltalk Dylan C, C++,Pascal Dylan Smalltalk Scheme Common Lisp Lisp )H Smalltalk Dylan Dylan Language Overview) Dylan Dylan )F3 CLOS (Common Lisp Object System), Oak Lisp, EuLisp Palatino class heterarchy) Courier <object> direct superclasses) <object> subclasses (superclasses) <object> Dylan direct instance) indirect instance) Dylan <object> general instance) Dylan Abstract Class) concrete class) Instantiable uninstantiable class) Class) (Sealed Class) X(open class) (Primary Class) (free class) (Functions) Dylan Dylan Dylan <function> eterarchy (DAG, directed acyclic graph) )< hierarchy Dylan Dylan heterarchy <function>, <generic-function>,<method> Palatino (method) specializers) applicable) gener ic function) Dylan Dylan Smalltalk first class) Palatino (Syntax) Lexical Notation) Dylan Courier ! & * < = > | ^ $ % @ _ - + ~ )l - + ~ ? / )0#+ - * / - = == < > <= >= ~= ~ & | ^ define method X (Numeric Classes) #x1f4e Dylan "abc" #"Hello" (Characters and Symbols) Courier Hello: Palatino (Characters and Symbols) #(1, 2, 3) #[1, 2, 3] /* ... */ #rest #next #all-keys #rest #next #all-keys (Naming Conventions) Dylan <window> <object> <character> <numb <stream> <list> *parse-level* *incremental-search-string* *machine-state* *window-count* Courier $end-of-file 0 subclass? even? 0 instance? Palatino reverse! reverse sort! getters) setters) -sette Getter Setter window-position window-position-setter table-size table-size-setter window-color window-color-setter my-window color green &window-color-setter (green, my-window) my-window.window-color := green (Expressions) Dylan (expressions) (outer expression) (top-level expression) begin begin Palatino (syntax forms) (Literal Constants) Courier "abc" "abc" foo: #(1, 2, 3) #(1, 2, 3) (Equality Comparisons) Variable References) Dylan define variable define method <window> {the class <window>} concatenate 0"{the generic function concatenate} " define variable my-variable = 25; my-variable my-variable begin let x = 50; x + x; Courier end; Palatino Dylan (first class) Function Calls) expression expression expression factorial factorial(x, y) Dylan Scheme Common Lisp (method(x) x + 1 end) (99) Syntax Forms) syntax form) syntax operators) efine variable method define variable define variable method method define variable foo = 3; argument.function argument function Courier %method (a :: <number>, b :: <number>) list (a - b, a + b); end method; Palatino variable := 12; macro (macros) ) Dylan (Special forms method (definitions define method define variable (Statement bodies) (implicit bodies) begin begin [Special Form] Symbol values body begin begin # close(airlock.outer-door); // 0# pressurize(airlock); // Courier # open(airlock.inner-door); // begin if (moon-phase == #"full") # wolf-form(werewolf); // 0# howl-at-moon(werewolf); // human-form(werewolf); end if; Palatino Semicolons) Special function call syntax) (Infix Operators) left-associative) (right-associative) unary unary binary binary binary binary Courier binary binary equality binary (identity) binary binary binary binary binary binary binary binary Palatino (Equality Comparisons) Dylan first class) define method op arg (Slot Reference) Dylan argument.function function argument argument )T function moo.goo.gai.pan america.capital "Washington, D.C." / me.mother.current-husband.favorite-child == me Dylan Palatino (Array Reference) Dylan Courier foo[i] element(foo, i) foo[i , ... i aref (foo, i , ... i element " define constant vect = #[7, 8, 9] defined vect vect[0] sequence[arg , arg sequence element in Dylan module> in Dylan module> Dylan Syntax of Dylan Files) Dylan (Dylan source code file) Dylan header) body) * ISO 646 7 Palatino Courier module: module-name [Header keyword] author: arbitrary text [Header keyword] copyright: arbitrary text [Header keyword] version: arbitrary text [Header keyword] Dylan module: )` quickdraw author: J. Random Rect )`1Linear Wheels, Inc., "Where quality is a slogan!" rect@linear.com 0<copyright: (c) 1993 Linear Wheels, Inc., All rights reserved version: .3 alpha (not fully tested) 0"define constant $black-color = ... Palatino (Variables) Dylan lexical variables) module variables) environment) Courier (Module Variables) define variable bindings [Definition] define variable bindings variable variable }* [ #rest rest-variable-name variable variable-name variable-name )0 variable- names rest-variable -name bindings bindings (Checking Types) (Binding Multiple Values) define variable foo = 10; foo + foo; define constant bindings [Definition] define constant define variable define class define generic define method Courier define generic define method Palatino (Lexical Variables) bindings [Special Form] bindings variable variable }* [ #rest rest-variable-name variable variable-name variable-name variable-names rest-variable-name bindings bindings (Checking Types) (Binding Multiple Values) begin let foo = 35; foo + foo end (shadow) define variable foo = 10; begin let foo = 20; let foo = 50; foo + foo end Courier local block Palatino (Checking Types) define variable variable-name type variable-name Dylan <type> types variable variable define variable begin 0" let x :: <integer> = sqrt (2); x end 9error: 1.4142135623730951 is not an instance of <integer> &define variable foo :: <integer> = 10; oo := sqrt (2) 9error: 1.4142135623730951 is not an instance of <integer> Binding Multiple Values) Dylan (multiple values) values let,define variable, define constant bindings bindings Palatino variable Courier variable }* [ #rest rest-variable-name values #rest the-values Symbol the-values [Function] the-values values(1, 2, 3); define variable, define constant variables variables begin 0+ let (foo, bar, baz) = values (1, 2, 3); list (foo, bar, baz) end #(1, 2, 3) 2 define method opposite-edges (center :: <number>, 04 radius :: <number>); , let (min, max) = edges (center, radius); values (max, min); end method; opposite-edges opposite-edges (100, 2); * variables variables variable )` variables rest-variable )| sequence) rest-variable rest- * variable Dylan begin 0& let (#rest nums) = edges (100, 2); nums; end #(98, 102) rest-variable rest-variable Courier begin let x = 10; let y = 20; let (x, y) = values (y, x); list (x, y); end #(20, 10) Palatino (Assignment) Dylan place new-value Symbol new-value [Special Form] new-value place place )l new-value new-value place Dylan place place )T new-value place , new-value define variable foo = 10; foo // 10 foo := 10 + 10; (Extended form) place extended form +define variable foo = vector (10, 6, 8, 5); Courier element(foo, 2) element(foo, 2) := "bar" "bar" #[10, 6, "bar", 5] Palatino u , ... arg ) := )# new-value -setter ( new-value, arg , ... arg (functional) function-name(arg , ..., arg ) := new-value ... arg new-value function-name function-name-setter >(Extended form using array reference or slot reference syntax) foo[2] := "quux" element (foo, 2) := "quux" element-setter ("quux", foo, 2) argument.function-name := value argument value function-name function-name-setter implicit element sequence[arg , arg ] := value Courier sequence Palatino value element-setter Palatino (Control Constructs) (True and False) Dylan Courier [Object] Dylan [Object] thing Symbol boolean [Function] thing (Conditionals) consequent elseif elseif-test elseif-consequent alternate values [Special Form] consequent elseif elseif-test elseif-test elseif-consequent elseif-test elseif-test )H alternate )H alternate Lisp Palatino )0 alternate Courier consequent elseif-consequent alternate consequent elseif- consequent )$ alternate &define method test (thing :: <object>) if (thing) #t else #f end if end method; test ("hello") test (#t) test (#f) define method show-and- tell (thing :: <object>); if (thing) print (thing); #t else #f end if end method; show-and-tell show-and-tell("hello") hello unless [Macro] unless Symbol values unless unless(detect-gas? (nose)) light(match) end unless Courier Palatino [Macro] otherwise => otherwise-body Symbol values body body body otherwise player1.money <= 0 => end-game(player1); player2.money <= 0 => end-game(player2); otherwise => move(player1); move(player2); end case; select target-form test [Macro] match ... match- match ... match- otherwise => otherwise-body select values match-list l otherwise body select target-form target value) match Courier Palatino body body body) otherwise )` otherwise select !select ( career-choice(student) ) rt:, music:, drama: 0! => "Dont quit your day job"; & literature:, history:, linguistics: % => "That really is fascinating"; science:, math:, engineering: # => "Say, can you fix my VCR?"; " otherwise => "I wish you luck"; end select; instance? Dylan select Common Lisp typecase 0!select ( my-object by instance? ) 8 <window>, <view>, <rectangle> => "a graphical object"; 9 <number>, <string>, <list> => "a computational object"; otherwise => "I dont know"; end select form1 form2 Symbol values [Macro] (or) forms form1 form2 form1 form2 form1 form2 values [Macro] (and) forms form1 form2 form1 form2 Palatino (Iteration Constructs) Courier while [Macro] while Symbol while while until [Macro] until until until clauses [Macro] until while end-test finally result-body value clauses clause iteration variable) end-test clauses (explicit step clauses) (collection clauses numeric clauses (Explicit step clauses) variable variable init-value next-value (Collection clauses) variable variable collection forward-iteration-protocol Palatino (Numeric clauses) Courier variable variable start above below bound increment init-value collection collection start bound H increment increment variable init-value type init-value )l variable start type start bound bound increment increment )D variable bound )N variable bound above )D variable bound )H variable bound below )D variable bound )H variable bound variable type Palatino end-test Courier end-test while end-test until , go to next-value )` variable increment type result-body result-body result-body result-body result-body +for ( thing = first-thing then next(thing), until done?(thing) ) do-some(thing) *#$for (j :: <integer> from 0 to height 0& for (i :: <integer> from 0 to width) erase(i,j); plot (i,j); end for; end for; for (city in olympic-cities, year from start-year by 4) # schedule-olympic-game(city, year) finally notify(press); sell(tickets); Courier for (i from 0 below 100, zombies from 0 below 100, $ normals from 100 above 0 by -1) % population[i] := zombies + normals Palatino (Non-local Exits) block exit-var [Special Form] cleanup cleanup-clause exception exception-clause block Symbol values block block cleanup-clauses cleanup-clauses cleanup-clauses exception-clauses block exit-var clauses exit-var (exit procedure) clause block (non-local exit) cleanup-clauses body block cleanup-clauses block block (return) open-files(); ... if (error) return(#f); end if; ... result cleanup close-files(); end block Palatino cleanup-clauses Courier block block cleanup-clauses +Restrictions on the use of exit procedures) (establishing block block lexical body) block block ? define constant foo = block (bar) method (n) bar(n) end; end block; ? foo(5) (intervening blocks cleanup cleanup cleanup cleanup Palatino (Comparisons) Dylan identity function equality identity function (Other Operations) identity Courier protocol) (Identity): (Transitivity): (Trichotomy): b), (a b), (b (Equality Comparisons) object1 object2 Symbol boolean [Function object1 object2 computationally equivalent )86) Dylan (a < b) ~(b < a) (antireflexivity ) (a == b) ~(a < b)) (a = b) (b = IEEE Dylan IEEE (immediate value) (mutable) ,)#! Palatino object1 Courier object2 Symbol boolean [Generic Function] key-test key-test tails object1 object2 boolean [Function] object1 object2 (Magnitude Comparisons) object1 object2 boolean [Generic Function] (prefix) object1 object2 boolean [Function] object object1 object2 Courier Palatino object1 object2 Symbol boolean [Function] object object1 object2 object1 object2 boolean [Function] object object1 object2 Palatino (Functions) (Function Defining Forms) %(Generic Functions and G. F. Methods) Courier fine generic define method define generic define generic define method define adjectives generic name parameter-list [Definition] define generic adjectives adjectives sealed adjectives Controlling Dynamism) parameter-list parameter-list (required pa )B rameters) congruent) (Parameter Lists) define method define adjectives method name parameter-list [Definition] implicit-body method name define method define generic define method Palatino (Parameter Lists) adjectives adjectives Courier sealed adjectives (Controlling Dynamism) parameter-list (Parameter Lists) implicit-body implicit-body implicit-body double double (define method double (thing :: <number>) thing + thing; end method; double double {the generic function double} double(10) double <number> <number> double double("the rain in Spain.") 0<error: no method for {the generic function double} was found / for the arguments ("the rain in Spain.") double *define method double (thing :: <sequence>) concatenate (thing, thing); end method; double double("the rain in Spain.") 0&"the rain in Spain.the rain in Spain." Palatino (Bare Methods) Dylan Courier method method parameter-list [Special Form] implicit-body method Symbol method method method method parameter-list implicit-body implicit-body parameter-list method (Parameter Lists) method(num1, num2) num1 + num2 end method {an anonymous method} // SORT sort(person-list, method(person1, person2) # person1.age < person2.age end method) begin 04 let double = method(number) number + number end; double(double(10)) end double double / define method double (my-method :: <function>) method (#rest args) apply (my-method, args); apply (my-method, args); #f end method end method; Courier double , define constant print-twice = double(print) print-twice print-twice {an anonymous method} & print-twice("The rain in Spain. . .") 0,The rain in Spain. . .The rain in Spain. . . print-twice(55) define method local Palatino method-spec , method-spec [Special Form] local self-recursive mutually-recursive method-spec method local gin...end names local 1 define method root-mean-square (s :: <sequence>) 0 local method average (nums) - reduce1 (\+, nums) / size (nums) end average, method square (n) n * n end square; % sqrt (average (map (square, s))) end method root-mean-square $ root-mean-square (#(5, 6, 6, 7 ,4)) 5.692099788303083 define method newtons-sqrt (x) local method sqrt1 (guess) if (close? (guess)) guess else ' sqrt1 (improve (guess)) end if Lisp )< Smalltalk Courier end sqrt1, method close? (guess) , abs (guess * guess - x) < .0001 end close?, ! method improve (guess) & (guess + (x / guess)) / 2 e nd improve; sqrt1 (x) end method newtons-sqrt newtons-sqrt (25) 5.000000000053723 Palatino (Parameter Lists) Dylan required parameters) rest parameters) (keyword parameters) next-method (return type declarations) variable specialized (singleton specializer syntax) variable expression variable :: singleton expression informally #rest keyword parameter specifiers) )` #all-keys #rest #rest Palatino next-method Courier #next next-method next- method define method next-method next-method next-method (Calling More General Methods) (a, b, c) (a :: <list>, b, #rest c) 0 (#rest a) (a, b, #key foo, bar) (#key bar, baz, bim) (#rest all, #key fee, fi) Argument Passing Protocol) (accept keyword arguments) #rest V #all-keys accept all keyword arguments) #rest '(accept a variable number of arguments) #rest )4&(require a fixed number of arguments) recognize) mandatory keywords) Palatino permit) next-met "(Specializing Required Parameters) identities) specializing) Courier double <number> ) define method double (thing :: <number>) thing + thing end method double(10) double(4.5) )S singleton Courier (a :: <window>, b, c) Palatino window (a :: <window>, window b :: <character>, character (a :: <window>, b :: <character>, window character c :: singleton (0)) (a, b :: <string>, #rest c) string (a :: <vector>, b, #key foo, bar) vector Dylan singleton specializers) (a :: <window>, b :: <character>, window character c == 0) Keyword Parameters) default keyword parameter keyword parameter default Palatino default default default Courier default next- method 7define method percolate (#key brand (#"maxwell-house"), ' cups (4), 3 strength (#"strong")) & make-coffee (brand, cups, strength); end method; 5define method layout (widget, #key position: the-pos, 2 size: the-size) % let the-sibling = sibling (widget); + unless (the-pos = position (the-sibling)) align-objects (wid %get, the-sibling, the-pos, the-size); end method; (percolate (brand: #"folgers", cups: 10); percolate (strength: #"weak", $ brand: #"tasters-choice", cups: 1); ,layout (my-widget, position: point (10, 10), ) size: point (30, 50)); 1layout (my-widget, size: query-user-for-size() ); position: position position position shadow) (Result Values) variable-name type-expression type-expression <object> Palatino variable-name type- expression variable-name Courier #rest #rest (rest value declaration) #rest required value decla ration) conceptual sequence) => #rest x :: <object> <type-error> <type-error> define generic congruency rules) method define method define class define method define class => #rest x :: <object> (Parameter List Congruency) congruent parameter lists) Palatino (Method Dispatch) Palatino (Method specificit more specific than) (ambiguous methods) class precedence list) % Computing the Class Precedence List) Craig Chambers Cecil (U. Washington) CLOS Palatino ambiguous method Courier next-method ambiguous next method (Examples of method specificity) 4define class <sentient> (<life-form>) ... end class; 3define class <bipedal> (<life-form>) ... end class; 6define class <intelligent> (<sentient>) ... end class; 2define class <humanoid> (<bipedal>) ... end class; @define class <vulcan> (<intelligent>, <humanoid>) ... end class; <vulcan> <intelligent> <humanoid> <life-form> <bipedal> <sentient> <vulcan> $D(<vulcan>,<intelligent>,<sentient>,<humanoid>,<bipedal>,<life-form>) (<intelligent>,<sentient>) (<humanoid>,<bipedal>) <human> ?define class <human> (<humanoid>, <intelligent>) ... end class; <human> C(<human>,<humanoid>,<bipedal>,<intelligent>,<sentient>,<life-form>) \ <bipedal> <sentient> <vulcan> <human> <define class <vulcan> (<intelligent>, <humanoid>) end class; ;define class <human> (<humanoid>, <intelligent>) end class; 9define method psychoanalyze (being :: <intelligent>) ... Courier end method; 6define method psychoanalyze (being :: <humanoid>) ... end method; psychoanalyze <human> Palatino being <humanoid> <vulcan> being <intelligent> <vulcan> being <human> being superior-being <vulcan> being <human> being superior-being most-intelligent-being best-looking-being 01define method superior-being (a :: <intelligent>, 2 b :: <intelligent>) most-intelligent-being (a, b) end method; .define method superior-being (a :: <humanoid>, . b :: <humanoid>) best-looking-being (a, b) end method; $(Computing the Class Precedence List (local precedence order) class precedence list) Dylan deterministic) Dylan CLOS CLOS superior-being <vulcan> being <human> being <human> best- looking-being <vulcan> most-intelligent-being CLOS Palatino = {(c, c ), (c ), .... , (c ,..., c partial class precedence list) ,...,N ,...,C (N, M), ,....,C Calling More General Methods) Palatino Courier next-method next-method next-method #next next-method <float> double next-method next-method <number> & define method double (num :: <float>) 0- print("doubling a floating-point number") next-method() end method; uble(10.5) 0 doubling a floating-point number next-method Next-Method ,(Passing Different Arguments to Next-Method) next-method next-method next-method Dylan apply next-method ext-Method (The Next-Method Parameter) next-method next- method next- method define method method next-method #next next-method Palatino next-method Courier define method next-method #Reflective Operations on Functions) generic-function-methods generic-function [Function] Symbol sequence generic-function-methods generic-function generic-function <sealed-object-error> add-method generic-function method [Function] new-method old-method add-method generic-function method add-method define method add-method method method generic-function $generic-function-mandatory-keywords generic-function [Function] Palatino generic-function generic-function generic-function Courier function-specializers function Symbol sequence [Function] function-specializers function function function function-arguments function [Function] * required-number rest-boolean kwd-sequence function-arguments function function function function function function function-arguments applicable-method? ) function #rest sample-arguments [Function] boolean function sample-arguments sorted-applicable-methods [Function] generic-function #rest sample-arguments sequence1 sequence2 sorted-applicable-methods generic-function sample-arguments sequence1 sequence2 sequence2 Courier find-method Palatino ) !generic-function specializer-list [Function] Symbol {method find-method generic-function specializer-list generic-function <sealed-object-error> remove-method generic-function method method [Function] remove-method generic-function method method generic-function method remove-method generic-function method generic-function <sealed-object-error> '<function>, <generic-function>,<method> 1(The classes <function>, <generic-function>, and <method>) <function> [Abstract Class] <function> <function> <object> <generic-function> [Instantiable Class] <generic-function> <functio <generic-function> required: number-or-sequence <object> rest?: boolean Palatino Courier collection-of-keywords-or-#f all-keys?: boolean rest?: all-keys?: add-method define method define generic define method <method> [Class] <function> Palatino )N (Classes) Introduction) Dylan categorize) (slots) Courier singleton (Slots and slot access) fields instance variables (private) Dylan Dylan getter method) setter method) <point> define class <point> (<object>) slot horizontal; CLOS Courier slot vertical; end class; <point> horizontal vertical Palatino horizontal vertical horizontal-setter vertical-setter point horizontal coordinate) horizontal(my-point) horizontal-setter(10, my-point) horizontal(my-point) := 10; (Singleton types) 2 define method double (thing :: singleton(#"cup")) #"pint" end method double (#"cup") #"pint" double (10) Dylan ' define method double (thing == #"cup") Courier #"pint" end method double (#"cup") #"pint" Palatino (Defining New Classes) double Dylan define class define adjectives class class-name superclasses [Definition] )' slot-spec slot-spec class class-name define class define class class-name adjectives sealed primary abstract concrete (Controlling Dynamism) superclass superclass heterarchy) slot-spec slot-spec slot variable-name -setter slot-specs <menu> title title-setter action action-setter define class <menu> (<object>) slot title; slot action; Courier end class; Palatino initialize (Instance creation) (Slot Uniqueness) )p disjoint (Slot Options) slot-specs slot sp ecifications) 'initialization argument specifications) inherited slot specifications) (Slot Specifications) adjectives ] [ allocation getter-name #key setter init-keyword #.required-init-keyword init-value init-function getter-name (getter name) adjectives adjectives sealed adjectives (Controlling Dynamism) allocation (Specifying Allocation) Palatino setter init-keyword init-value init-function Courier virtual init-value: init-function: (Keywords allowed in slot- specs) init-keyword: required-init-keyword: keyword initializable ) bar-x bar-y keyword initializable) define class <bar> (<object>) slot bar-x, init-keyword: x:; slot bar-y, init-keyword: y:; end class <bar>; make(<bar>, x: 2, y: 3) make(<bar>) )j((Initialization Argument Specifications) H required) )@ optional) required keyword keyword #key keyword )8 keyword #key type init-value init-function )$#defaulted initialization arguments <bar> Courier define class <baz> (<bar>) required keyword x:; keyword y:, init-value: #t; end class <baz>; Palatino bar-y init-keyword define-class define-class init-value: init-function: required-init-keyword: init-value: init-function: (Inherited Slot Specifications) init-value: init-function: inherited slot getter-name #key init-value init-function getter-name init-value: init-function: init-value: init-function: init-value: init-function: init-value: init-function: init-value: init-function: Courier define class <animal> (<object>) slot n-legs, init-value: 4; end class; define class <spider> (<animal>) ' inherited slot n-legs, init-value: 8; end cl Palatino (Specifying Allocation) allocation instance class each-subclass virtual constant instance class each-subclass constant init-value virtual virtual) Dylan initialize slot-initialized? slot- initialized? Palatino (Keywords allowed in slot-specs) Courier setter getter-name "-setter" constant type: <object> init-value: init-value: init-function: init-value: init-function: init-function: init-function: init-value: init-keyword: init-keyword: init-keyword init-keyword: required-init-keyword: Courier required-init-keyword: Palatino init-keyword init- keyword: init-keyword required-init-keyword: init-keyword: init-value: init-function: (Filtered Slots) position <view> view> <displaced-view> position position <view> position <displaced-view> position position position-setter <view> <displaced-view> <displaced- view> next-method define class <view> (<object>) instance slot position; ... end class; &define class <displaced-view> (<view>) ... end class; .define method position (v :: <displaced-view>) ' displace-transform (next-method (v)); method; 0,define method position-setter (new-position, 5 v :: <displaced-view>) 7 next-method (undisplace-transform (new-position), v); end method; Courier define class <shape> (<view>) virtual slot image; - instance slot cached-image, init-value: #f; ... end class; &define method image (shape :: <shape>) cached-image (shape) 6 | (cached-image (shape) := compute-image (shape)); end method 08define method image-setter (new-image, shape :: <shape>) $ cached-image (shape) := new-image; end method; Palatino (Instance creation) initialize (Overview) shadow next-method )9"supplied initialization arguments) )u$(defaulted initialization arguments) Palatino Courier initialize initialize next-method() initargs initialize initialize )3#Definitions of make and initialize) class #key #all-keys instance [Generic Function] class Dylan initialize class class )0 singleton next-method class #rest !supplied-initialization-arguments instance [Method] class class deferred) Palatino "supplied-initialization-arguments Courier "supplied-initialization-arguments class initialize initialize custom initialize #rest !supplied initialization arguments present) initialize initialize instance #key #all-keys [Generic Function] initialize <triangle> !define class <triangle> (<shape>) . slot side-a, required-init-keyword: side-a:; . slot side-b, required-init-keyword: side-b:; slot angle-C; 5 virtual slot side-c, required-init-keyword: side-c: Courier end class <triangle>; *define method initialize (x :: <triangle>, 7 #key side-a, side-b, side-c) next-method(); = x.angle-C := three-sides-to-angle (side-a, side-b, side-c); end method initialize; initialize Palatino next-method very early) (convention) Dylan next-method initialize initialize permits initialize instance :: <object> [Method] initialize initialize next-method() )y%(Initialization Argument Inheritance) favorite-beverage define class <person> (...) % slot favorite-beverage, init-value: #"milk", 05 init-keyword: favorite-beverage:; ) slot name required-init-keyword: name:; end class <person>; #define class <astronaut> (<person>) 1 keyword favorite-beverage: init-value: #"tang"; " keyword name: init-value: "Bud"; end class <astronaut>; name: <astronaut> name: required-init-keyword: required-init-keyword: Palatino Courier type: <object> required-init-keyword: optional) init-keyword: init-value: init-function: required-init-keyword: init-value: init-function: required-init- keyword: init-value init-function init- value: init-function: )(Initialization of Class Allocated Slots) Palatino Courier class each-subclass init-value: init-function: init-value: init- * function: &(Testing the Initialization of a Slot) slot-initialized? instance getter Symbol boolean [Function] slot-initialized? getter instance slot-initialized? getter instance (Reflective Operations on Types) instance? object type boolean [Function] instance? object subtype? type boolean [Function] subtype? Courier object-class Palatino object Symbol class [Function] object-class object all-supercla class sequence [Function] all-superclasses class class <object> class <sealed-object-error> direct-superclasses class sequence [Function] direct-superclasses class class define class define class class <sealed-object-error> direct-subclasses class sequence [Function] direct-subclasses class class class <sealed-object-error> (Coercing and Copying Objects) shallow copies) weak link) Courier Palatino class object Symbol instance [Generic Function] object class class object object class object <sequence> shallow-copy object new-object [Generic Function] shallow-copy object object Dylan <collection> object class-for-copy class-for-copy object class [Generic )0 Function] class-for-copy mutable) class-for- <object> class-for- <sequence> explicit-key- collection class-for-copy <explicit-key-collection> class-for-copy <type>, <class>, <singleton> .(The classes <type>, <class>, and <singleton>) <type> [Abstract Class] <type> <class> <type> <type> <object> <class> [Abstract Instantiable Class] Palatino Courier <class> <class> <class> <type> define class sealing directives) <sealed-object-error> <class> superclasses: superclasses: <object> define class slots: getter: setter: type: <object> deferred-type: init-value: init- function: Courier init-function: init-value: init-keyword: Palatino required- init-keyword: required-init-keyword: init-keyword init-keyword: init-keyword init- keyword: init-value: init-function: allocation: )l instance: class: each- subclass: constant: virtual: define class adjective) <singleton> [Instantiable Class] <singleton> object: single singleton object Symbol singleton [Function] singleton object Courier singleton( Palatino object make(<singleton>, object: object 8$0* %X`PD@ 0*n=2 !"#$ 5'4&< * ' 6 @R@7 `/ 9 M0896:57;G*E1&2 '+H<3 p 0p`P 1.'/0J 5 L F 9@ X0l0 ;=>&6? 0HT 0H ' .! #30'()G-H>?2$. EFM<; +',)/- \( ~0 `_@ ` !"#$ 5'4&< M0896:57;G*E1&2 '+H<3 1.'/0J >0f0 ;=>&6? ' .! #30'()G-H>?2$. EFM<; +',)/- temp.0001 Universal set MacHTTP SoftwareFolderion 0.15 mutsumi Mutchan IOFST Palatino Courier SymbolA bPREC nPRVS zCAPN